Structure for a circuit function that implements a load when reservation lost instruction to perform cacheline polling

ABSTRACT

A design structure for a circuit function that implements a load when reservation lost instruction for performing cacheline polling is disclosed. Initially, a first process requests an action to be performed by a second process. The request is made via a store operation to a cacheable memory location. The first process then reads the cacheable memory location via a conditional load operation to determine whether or not the requested action has been completed by the second process, and the first process sets a reservation at the cacheable memory location if the requested action has not been completed by the second process. The conditional load operation of the first process is stalled until the reservation at the cacheable memory location has been lost. After the requested action has been completed, the reservation in the cacheable memory location is reset by the second process.

The present application is a continuation-in-part of U.S. patentapplication Ser. No. 11/377,504, filed Mar. 16, 2006. Benefit ofpriority is hereby claimed under 35 U.S.C. §120 to U.S. patentapplication Ser. No. 11/377,504, which is incorporated by referenceherein in its entirety and for all purposes.

CROSS REFERENCE TO RELATED APPLICATIONS

The present application is related to the following United States patentapplications, which are each hereby incorporated by reference in theirentireties:

1) U.S. patent application Ser. No. 11/377,505 (Docket No.AUS920050474US1)

2) U.S. patent application Ser. No. 11/377,506 (Docket No.AUS920050475US1)

BACKGROUND

1. Technical Field

Embodiments of the present invention relate generally to data processingsystem operation and more particularly to a design structure for acircuit function that implements a load when reservation lostinstruction to perform cacheline polling.

2. Description of the Related Art

At the advent of modern computing, information handling (e.g., computer)systems comprised a limited number of components including a singleprocessor, system memory, and a small number of input/output (I/O)devices such as display devices, keyboards, and, in conjunction with thecreation of graphical user interfaces, cursor control devices (e.g.,mice, trackballs, or the like). As information handling systems havedeveloped however, the number of system components which interface witheach other via communication and competition for shared system resourceshas increased dramatically. Modern, conventional information handlingsystems may therefore include a wide variety of system components (e.g.,multiple processors using SMP, ASMP, NUMA, or similar configurations,co-processors, direct memory access controllers, and I/O devices each ofwhich may include additional processors, registers, and memory).

In order to coordinate the activity of system components in moderninformation handling systems, a number of techniques have beenimplemented. Interrupts, coupled with interrupt service routines orhandlers may be utilized by information handling system components tocommunicate and/or to indicate the occurrence of an event. Similarly,memory-mapped I/O and port or “port-mapped” I/O may be utilized toprovide communication between system components (e.g., processors andI/O devices).

The coordination of activity among elements of an information handlingsystem is of particular importance in the transfer of data betweenelements for the purposes of performing input/output (I/O) operations.For example, after an information handling system processor hasdeposited data in a buffer intended for handling by an I/O device oranother processor in a multiprocessor system, the data providingprocessor will typically notify the I/O device or data-receivingprocessor that the transfer of data to the buffer is complete. In aconventional information handling system, such notification is typicallyperformed by writing a specific data value into a memory mappedinput/output (MMIO) register within the I/O device or data-receivingprocessor. After a write operation to an associated MMIO register hasbeen detected, the I/O device or data-receiving processor may retrievedata from the buffer via a direct memory access (DMA).

In some conventional information handling systems the completion of DMAretrieval of data can be detected via MMIO register polling or viainterrupts. Neither MMIO register polling nor interrupts is an efficientmechanism for detecting the completion of the DMA however becauseinterrupt overhead is typically too great for relatively small buffersand MMIO register polling inefficiently utilizes bus bandwidth whichcould otherwise be used for DMA transfers, increasing overall systemthroughput.

In another conventional technique for detecting the completion of a DMAknown as “cacheline polling” a predetermined “busy” indicator data valueis written into a cacheable memory location, typically known as a bufferflag or semaphore, prior to notifying an I/O device (e.g., via MMIO) ofa buffer's availability. The processor then polls the buffer flag for apredetermined “not busy” indicator data value to detect the completionof a corresponding DMA. Since the data is already modified in theprocessor's cache, cacheline polling does not generate any additionalbus activity. After the completion of (DMA) data retrieval from thebuffer, the I/O device or receiving processor writes a “not busy”completion data value to the buffer flag. The new buffer flag value canthen be accessed by the data-providing processor via a normal cachecoherency protocol during which the “busy”-indicating buffer flag datain cache memory is invalidated or replaced by a new completion value.

From a system standpoint, cacheline polling is an efficient pollingmechanism. However, in order to implement cacheline polling thedata-providing processor executes a set of “polling” instructionsrepeatedly until the DMA transfer is complete and the buffer flag valueis updated, thus wasting valuable system resources (e.g., processorcycles, bus cycles, electrical power, instruction or thread dispatchslots, or the like).

SUMMARY

The invention is directed to a design structure for a circuit functionthat implements a load when reservation lost instruction to performcacheline polling. In accordance with an embodiment of the presentinvention, a first process requests an action to be performed by asecond process. The request is made via a store operation to a cacheablememory location. The first process then reads the cacheable memorylocation via a conditional load operation to determine whether or notthe requested action has been completed by the second process, and thefirst process sets a reservation at the cacheable memory location if therequested action has not been completed by the second process. Theconditional load operation of the first process is stalled until thereservation at the cacheable memory location has been lost. After therequested action has been completed, the reservation in the cacheablememory location is reset by the second process.

The foregoing is a summary and thus contains, by necessity,simplifications, generalizations and omissions of detail; consequently,those skilled in the art will appreciate that the summary isillustrative only and is not intended to be in any way limiting. As willalso be apparent to one of skill in the art, the operations disclosedherein may be implemented in a number of ways including implementationin hardware, software, or a combination thereof, and such changes andmodifications may be made without departing from this invention and itsbroader aspects. Other aspects, inventive features, and advantages ofthe present invention, as defined solely by the claims, will becomeapparent in the non-limiting detailed description set forth below.

BRIEF DESCRIPTION OF THE DRAWINGS

The present invention may be better understood, and its numerousfeatures and advantages made apparent to those skilled in the art byreferencing the accompanying drawings in which:

FIG. 1 illustrates a communications network including an informationhandling system according to an embodiment of the present invention;

FIG. 2 illustrates a high-level block diagram of an information handlingsystem according to an embodiment of the present invention;

FIG. 3 illustrates a block diagram representation of a selected portionof an information handling system capable of performing a load whenreservation lost instruction according to an embodiment of the presentinvention;

FIG. 4 illustrates a state diagram of a state machine for managing areservation for a load when reservation lost instruction according to anembodiment of the present invention;

FIG. 5 illustrates a flow diagram of process to perform cachelinepolling utilizing a load when reservation lost instruction according toan embodiment of the present invention; and

FIG. 6 is a flow diagram of a design process used in semiconductordesign, manufacture, and/or test, according to an embodiment of thepresent invention.

The use of the same or similar reference symbols within the accompanyingdrawings is intended to indicate similar or identical items.

DETAILED DESCRIPTION OF AN ILLUSTRATIVE EMBODIMENT

The following sets forth a detailed description of at least thecontemplated mode for carrying out the one or more systems, devicesand/or processes described herein. The description is intended to beillustrative and should not be taken to be limiting.

In the following detailed description, numerous specific details such asspecific method orders, structures, elements, and connections have beenset forth. It is to be understood however that these and other specificdetails need not be utilized to practice embodiments of the presentinvention. In other circumstances, well-known structures, elements, orconnections have been omitted, or have not been described in particulardetail in order to avoid unnecessarily obscuring this description.

References within the specification to “one embodiment,” “anembodiment,” or “embodiments” are intended to indicate that a particularfeature, structure, or characteristic described in connection with theembodiment is included in at least one embodiment of the presentinvention. The appearance of such phrases in various places within thespecification are not necessarily all referring to the same embodiment,nor are separate or alternative embodiments mutually exclusive of otherembodiments. Moreover, various features are described which may beexhibited by some embodiments and not by others. Similarly, variousrequirements are described which may be requirements for someembodiments but not other embodiments.

Embodiments of the present invention provide a load when reservationlost instruction for performing cacheline polling embodied within amethod, machine-readable medium, and an information handling system.FIG. 1 illustrates a communications network including an informationhandling system according to an embodiment of the present invention.

As illustrated in FIG. 1, system 101 includes a network 104 to which aplurality of information handling systems (e.g., computers and computingdevices) are coupled. In various embodiments of the present invention,network 104 may comprise a LAN, a global network, such as the Internet,or any other communications network. In the embodiment of FIG. 1,information handling systems coupled to network 104 include clientcomputers 106, server computers 108, personal digital assistants (PDAs)110, digital television (DTV) 112 and may further comprise other wiredor wireless computers and computing devices not shown. In theillustrated embodiment, the processing elements employed by the memberinformation handling systems of network 104 are constructed from acommon computing module. These processing elements also preferably allhave the same instruction set architecture (ISA) and perform processingin accordance with a common processor instruction set.

In the embodiment of FIG. 1, the number of computing modules includedwithin any particular processing element depends upon the processingpower required by the information handling to be performed by thatprocessing element. For example, since servers 108 of system 101 performmore processing of data and applications than clients 106, servers 108contain more computing modules than clients 106. PDAs 110, on the otherhand, perform a relatively smaller amount of processing. In theillustrated embodiment, each computing module contains a processingcontroller and a plurality of identical processing units for performingparallel processing of the data and applications transmitted overnetwork 104.

This homogeneous configuration for system 101 facilitates adaptability,processing speed and processing efficiency. Because each member ofsystem 101 performs processing using one or more (or some fraction) ofthe same computing module, the particular computer or computing deviceperforming the actual processing of data and applications is lessrelevant than in conventional systems. The processing of a particularapplication and data, moreover, can be shared among the network'smembers. By uniquely identifying the cells comprising the data andapplications processed by system 101 throughout the system, theprocessing results can be transmitted to the computer or computingdevice requesting the processing irrespective of where this processingoccurred. Because the modules performing this processing have a commonstructure and employ a common ISA, the computational burdens of an addedlayer of software to achieve compatibility among the processing elementsis avoided. This architecture and programming model facilitates theprocessing speed necessary to execute, e.g., real-time, multimediaapplications.

To take further advantage of the processing speeds and efficienciesfacilitated by system 101, the data and applications processed by thissystem are packaged into uniquely identified, uniformly formattedsoftware cells 102. Each software cell 102 contains, or can contain,both applications and data. Each software cell 102 also contains an IDto globally identify the cell throughout network 104 and system 101.This uniformity of structure for the software cells, and the softwarecells' unique identification throughout the network, facilitates theprocessing of applications and data on any computer or computing deviceof network 104. For example, a client 106 may formulate a software cell102 but, because of the limited processing capabilities of client 106,transmit this software cell to a server 108 for processing. Softwarecells can migrate, therefore, throughout network 104 for processing onthe basis of the availability of processing resources on the network.

The homogeneous structure of processing elements and software cells ofsystem 101 also avoids many of the problems of today's heterogeneousnetworks. For example, inefficient programming models which seek topermit processing of applications on any ISA using any instruction set,e.g., virtual machines such as the Java virtual machine, are avoided.System 101, therefore, can implement broadband processing far moreeffectively and efficiently than conventional networks.

FIG. 2 illustrates a high-level block diagram of an information handlingsystem according to an embodiment of the present invention. While aparticular number and arrangement of elements have been illustrated withrespect to the information handling system of FIG. 2, it should beappreciated that embodiments of the present invention are not limited todata processing systems having any particular number, type, orarrangement of components and so many encompass a wide variety of dataprocessing system types, architectures, and form factors (e.g., networkelements or nodes, personal computers, workstations, servers, or thelike).

The depicted information handling system of FIG. 2 is one example of aCell Broadband Engine (CBE) architecture in which exemplary aspects ofthe present invention may be implemented. As shown in FIG. 2, CBE 200includes a power processor element (PPE) 210 and multiple synergisticprocessor elements (SPEs) 220-234 communicatively coupled together andwith additional system elements described further herein via a highbandwidth internal element interconnect bus (EIB) 286. CBE 200 of theillustrated embodiment further includes one or more external buses ordevices 290 coupled to EIB 286 via a bus interface controller (BIC) 287and a shared memory 289 coupled to EIB 286 via a memory interfacecontroller (MIC) 288 as shown.

CBE 200 may be a system-on-a-chip such that each of the elementsdepicted in FIG. 2 may be provided on a single microprocessor chip.Moreover, in one embodiment CBE 200 is provided as a heterogeneousprocessing environment in which each of SPEs 220-234 may receivedifferent instructions from each of the other SPEs in the system.Moreover, the instruction set for each of the SPEs is different fromthat of PPE 210, e.g., PPE 210 may execute Reduced Instruction SetComputer (RISC) based instructions while SPEs 220-234 execute vectorizedinstructions.

In the illustrated embodiment of FIG. 2, SPEs 220-234 are coupled toeach other and to PPE 210 via EIB 286. Additionally, SPEs 220-234 areeach coupled to MIC 288 and BIC 287 via EIB 286. MIC 288 provides acommunication interface to shared memory 289. Shared memory 289 maycomprise any of a number of system memory-type storage elements such asrandom access memory (RAM), read-only memory (ROM), flash memory, or thelike. BIC 287 provides a communication interface between CBE 200 andother external buses and devices 290. Exemplary external devices mayinclude traditional I/O devices such as keyboards, displays, printers,cursor control devices (e.g., trackballs, mice, tablets, etc.),speakers, and microphones; storage devices such as fixed or “hard”magnetic media storage devices, optical storage devices (e.g., CD or DVDROMs), solid state storage devices (e.g., USB, Secure Digital SD™,CompactFlash™, MMC, or the like), removable magnetic medium storagedevices such as floppy disks and tape, or other storage devices ormediums; and wired or wireless communication devices or media (e.g.,communication networks accessed via modem or direct network interface).

In one embodiment of the present invention, PPE 210 is a dual threadedprocessing element. The combination of this dual threaded PPE 210 andthe eight SPEs 220-134 makes the CBE 200 capable of handling 10simultaneous threads and over 228 outstanding memory requests. In acommon operational environment, PPE 210 acts as a controller for theeight SPEs 220-234 which handle most of the computational workload. PPE210 may be used to execute one or more conventional operating systemswhile SPEs 220-234 perform vectorized floating point code execution, forexample.

In one embodiment, PPE 210 comprises a power processor unit (PPU) orcore and associated level 1 (L1) and level 2 (L2) caches (not shown) andeach of SPEs 220-234 comprise a synergistic processing unit (SPU),memory flow control units, local memory or store, and a bus interfaceunit comprising a combination direct memory access (DMA) controller,memory management unit (MMU), and bus interface unit (not shown). In oneexemplary embodiment, the described local memory or store comprises a256 KB instruction and data memory which is visible to PPE 210 and canbe addressed directly by software.

PPE 210 may load SPEs 220-134 with small programs or threads, chainingthe SPEs together to handle each step in a complex operation. Forexample, a set-top box incorporating CBE 200 may load programs forreading a DVD, video and audio decoding, and display, and the data wouldbe passed off from SPE to SPE until it finally ended up on the outputdisplay. At 4 GHz, each SPE 220-234 gives a theoretical 32 GFLOPS ofperformance with PPE 210 having a similar level of performance. Inoperation, PPE 210 may also execute instructions and handle or processdata retrieved from shared memory 289 into its local registers or cachesvia MIC 288. Similarly, an external device 290 may access shared memory289, for example via BIC 287 and one or more DMA controllers within SPEs220-234.

FIG. 3 illustrates a block diagram representation of a selected portionof an information handling system capable of performing a load whenreservation lost instruction according to an embodiment of the presentinvention. Within the present description, similar references numeralshave been utilized to denote corresponding system elements between theinformation handling systems of FIGS. 2 and 3. For example, PPE 310 ofthe illustrated embodiment of FIG. 3 corresponds to PPE 210 of FIG. 2.Information handling system 300 of FIG. 3 includes a PPE 310 which, viaEIB 386, is coupled to shared memory 389 and an external device 390utilizing MIC 388 and BIC 387, respectively.

In the illustrated embodiment of FIG. 3, shared memory 389 includes acacheable memory location 336 including data which specifies a bufferflag data value as shown. PPE 310 includes a power processor unit (PPU)316 hierarchically coupled to an L1 cache 312 and L2 cache 314 as shown.In the embodiment of FIG. 3, PPU 316 includes a number of functionalunits and data storage elements. More specifically, PPU 316 comprises aload/store unit 318 utilized to execute memory accessing instructions(e.g., loads from memory and stores to memory) and a condition register320 which stores data in the form of bits or flags indicating thecurrent state of PPU 316, reflecting the result of certain dataprocessing or information handling operations (e.g., data overflow orunderflow, positive or negative result, or the like).

Each of L1 cache 312 and L2 cache 314 include a cache management unit(CMU) (e.g., CMU 322 of L1 cache 312 and CMU 328 of L2 cache 314) aswell as a storage element (e.g., storage element 324 of L1 cache 312 andstorage element 332 of L2 cache 314). CMUs 322 and 328 are each used tocontrol the storage of data and/or instructions within a correspondingone of storage elements 324 and 332, implementing, for example,cacheline replacement algorithms, updating cacheline state or statusmetadata, or the like. Storage elements 324 and 332 in turn are utilizedto store lines or blocks of data comprising application data and/orinstructions as well as accompanying metadata (e.g., cache tags, statusbits, or the like). While CMUs 322 and 328 has been depicted as integralunits or modules of their respective caches, in alternative embodimentsof the present invention CMUs 322 and/or 328 or the functionalitythereof may be provided in other configurations (e.g., within a singleone of L1 cache 312 and L2 cache 314, within PPU 316, as a separate unitor module, or a combination thereof)

According to one embodiment of the present invention, PPU 316 may beutilized to perform cacheline polling via the execution of a load whenreservation lost (LDRL) instruction as will now be described. Inoperation, load/store unit 318 of PPU 316 may be initially used toperform a store operation to cause data specifying a “busy” buffer flagindicator data value (e.g., 0xBB) to be stored within cacheable memorylocation 336 of shared memory 389 as indicated by dashed line 338. Inthe illustrated embodiment, the described store operation is utilized tosignal an associated external device 390 (e.g., a graphics device) thatdata to be retrieved by the device has been stored within an associatedbuffer (e.g., a dedicated portion of shared memory 389 or other memorywithin or external to, information handling system 300. In otherembodiments of the present invention, additional operations (e.g.,exception or interrupt generation, signaling, MMIO write operations, orthe like) may be utilized to notify external device 390 that data hasbeen written to the buffer flag stored within cacheable memory location336 and that the retrieval of data from the described buffer maycommence.

Once PPU 316 performs the described store operation, a cacheline pollingfunction or routine may be performed utilizing PPE 310 in which a LDRLinstruction may be executed to cause data stored within cacheable memorylocation 336 of shared memory 389 to be stored within a register (e.g.,a general purpose register) within PPU 316 (not shown). As describedfurther herein, such a LDRL instruction causes a reservation to be setby storing a specific data value within a reservation register 330within L2 cache 314. In one embodiment a reservation is set by storing alogical ‘1’ within a reservation bit of reservation register 330 and amemory address of a corresponding region of memory (e.g., a specificmemory location or region associated with cacheable memory location 336of shared memory 389) with which the reservation is associated. In thedescribed embodiment, the setting and resetting of a reservation withinreservation register 330 causes a corresponding reservation status bitto be set or reset within condition register 320. Although reservationregister 330 has been illustrated as within CMU 328 of L2 cache 314, inalternative embodiments of the present invention such a reservationregister or data may be stored elsewhere within information handlingsystem 300 (e.g., within L1 cache 312, PU 316, a separate bus/EIBinterface unit, or the like).

After the reservation has been set, the described LDRL instruction isstalled (e.g., temporarily suspended from execution orissuance/completion) until the reservation is cleared or “reset”following the occurrence of one or more of a number of informationhandling system events as will be described more fully herein and asindicated by a corresponding reservation status bit within conditionregister 320. In one embodiment, a reservation may be reset by CMU 328of L2 cache 314 using a cache “snoop” operation following the detectionof an attempt, request, or performance of a write (e.g., by externaldevice 390) to cacheable memory location 336 as indicated by dashed line340. Once external device 390 has modified the buffer flag data storedwithin cacheable memory location 336, causing the reservation to bereset and consequently “lost” the previously-stalled LDRL instructionmay be resumed, resulting in the hierarchical storage of the bufferflag's data value within storage elements 324 and 332 of L1 cache 312and L2 cache 314, respectively, and eventually within the designatedregister within PPU 316.

As will be described more fully herein, once the LDRL operationsuccessfully completes, the retrieved buffer flag data value may becompared to known “busy” or “not busy” buffer flag indicator datavalues. The described comparison may be utilized to determine whetherexternal device 390's retrieval (e.g., via DMA transfer) of datapreviously stored within an associated buffer has completed such that,for example, the associated buffer may be reused for additional datatransfer to external device 390 or other devices or system elements ofinformation handling system 300.

FIG. 4 illustrates a state diagram of a state machine for managing areservation for a load when reservation lost instruction according to anembodiment of the present invention. The illustrated “state machine”therefore represents operations to be performed by, or functionalityincorporated into, one or more elements of an information handlingsystem (e.g., information handling system 300 of FIG. 3). In oneembodiment, such functionality is incorporated into a processing elementor unit such as PPU 316 of FIG. 3, in other embodiments, suchfunctionality maybe embodied within a standalone or additional systemelement capable of monitoring and controlling the operations of anassociated information handling system. In one embodiment of theinvention, the functionality represented by the state diagram of FIG. 4is instantiated for each hardware thread initiated or supported.

As shown, state machine 400 includes five separate states, namely, stateS0, state S1, state S2, state S3 and state S4. In one embodiment, astore instruction is utilized to set a buffer flag “busy” indicator datavalue and to initialize the state of buffer data to be accessed. Inanother embodiment, the described store instruction is further utilizedto set a load reservation.

In an initial state S0, state machine 400 records the address of thecacheline for buffer flag after the receipt of a conditional load, andenters state S1. The described conditional load targets the addresscorresponding to a cacheline storing a buffer flag. Multiple loadreservations can exist concurrently.

In a cache state check state S1, the state of the cache memory ischecked. If the cacheline storing a buffer flag is invalid, statemachine 400 enters state S4. If the cacheline storing a buffer flag ismodified or shared, state machine 400 enters state S2.

In a wait on reservation to be lost state S2, state machine 400 remainsidle while the load reservation exist for the load operation. After theload reservation has been lost, state machine 400 enters state S4.

A cache memory has a mechanism to detect if another processor isaccessing one of its cachelines. This mechanism is commonly referred toas a snoop machine. A similar process can be used by state machine 400to determine if a cacheline is being modified by another processor ordevice. In addition, state machine 400 watches for store instructions tothe buffer flag by another thread on the same processor or otherprocessors sharing the cache memory.

If the only exit from state S2 was due to the cacheline storing a bufferflag being modified, the processor could potentially deadlock (i.e.,never make any progress). In one or more alternative embodiments of thepresent invention, other exit conditions are added to cause statemachine 400 to enter state S4 even if the load reservation has not beenlost in order to avoid a potential deadlock condition. For example, aninterrupt may be utilized to initiate or cause a transition from stateS2 to state S4. If an interrupt is directed towards a stalled processoror processor thread in the described embodiment, state machine 400 willexit to state S4 to allow the interrupt to be processed. If theinterrupt is not processed, the processor or other device may neverupdate the buffer flag.

In another exemplary embodiment, a timeout may be utilized to cause atransition from state S2 to state S4. To avoid waiting an unacceptablylong period of time for a transition to occur between state S2 and stateS4, software may be utilized to trigger a timeout for the cachelinepolling period. With the timeout option, state machine 400 will exit tostate S4 after a specified amount of time. In alternative embodiments ofthe present invention, a timeout value can be set prior to or as aparameter of the load when reservation lost instruction.

In the illustrated state diagram of FIG. 4, a wait on reservation to belost (buffer flag not in processor's cache) state S3 may be entered if acacheline storing a buffer flag is castout due to other loadinstructions or store instructions requiring the same cacheline. StateS3 is substantially similar to the previously-described state S2 withthe exception that the buffer flag is not stored in the processor'scache memory. The same exit conditions exist for state S3 as they arefor state S2 however, the cacheline storing a buffer flag is marked asbeing no longer valid (i.e., modified or shared) in the processor'scache in state S3. In one embodiment, where cacheline castout operationsmay cause a reservation to be reset, State S3 may be eliminated. Inanother embodiment, a transition from state S3 back to state S2 mayoccur if the cache memory preloads data from the system bus (e.g., cacheinjection).

In a data forward state S4, the state of the cacheline storing a bufferflag is examined to determine if the buffer flag-storing cachelinecontains valid data (i.e., shared, modified, etc.). If so, the data isforwarded to the processor and state machine 400 reenters state S0. Thisis the case when the buffer flag data has not been modified by aprocessor or device because the loss of the load reservation is causedby another event (e.g., an interrupt or timeout). In this case, thebuffer flag comprises data specifying a “busy” indicator data value anda compare instruction will then be executed. If an interrupt is pending,the interrupt will be processed next. When the interrupt returns, abranch will be taken if the data returned was the “busy” indicator datavalue. If the branch is taken, then the load reservation initiating thecacheline polling routine will start the load reservation process again.

If the cacheline storing a buffer flag contains invalid data, a “loadmiss” is generated and buffer flag data is requested from shared memoryvia the bus. When the buffer flag data is returned, the data isforwarded to the processor, and the state of the cache memory isupdated. State machine 400 then enters state S0. This process is thesame as a normal load operation that misses in a cache memory. In thiscase, the data has been modified by the device to comprise a “not busy”indicator data value (e.g., 0xBC or any value not equal to 0xBB).

Thereafter, a compare instruction is performed. If the data returneddoes not specify the “busy” indicator data value, a branch will not betaken and the cacheline polling routine exits, indicating that anexternal device has completed the retrieval of data from the associatedbuffer.

There are several conditions which may cause a reservation to be lostincluding the invalidation of a cacheline containing data referenced bythe address of the load when reservation lost instruction, themodification of the data associated with the address of the load whenreservation lost instruction by the same processor or another processorsharing the same cache memory, the presentation of an interrupt to astalled thread previously executing a load when reservation lostinstruction, conventional cacheline replacement/ejection/castout causedby a memory operation of the same processor or another processor sharingthe cache where the S3 state previously-described, or the occurrence ofone or more other exit conditions (e.g., timeouts for the loadconditional instruction).

In the described embodiments, the invalidation of a cacheline can becaused by a device or other processor reading the cacheline with theintention to modify (RWITM) the data stored therein, or by a device orother processor writing the cacheline (write with flush).

While the buffer flag or semaphore has been described herein as storedwithin a cacheable memory location, in alternative embodiments thememory location need not be cacheable. More specifically, methods orprocesses of the present invention may be applied to a buffer flaglocated in a non-cacheable memory location as long as the processor hasa means to snoop for a device updating the buffer flag-containing memoryaddress. Locating the buffer flag within a non-cacheable memory locationis made apparent by the existence of state S3. In state S3, the bufferflag is not valid in the processor's cache, which is the same state thatwould exist for a non-cacheable flag.

FIG. 5 illustrates a flow diagram of process to perform cachelinepolling utilizing a load when reservation lost instruction according toan embodiment of the present invention. For purposes of illustration,the depicted process embodiment will be described with respect to systemelements of information handling system 300 of FIG. 3. Initially in theillustrated process embodiment of FIG. 5, load/store unit 318 of PPU 316fills a buffer within shared memory 389 with data (e.g., data to behandled or processed by external device 390) (process block 502). In analternative embodiment of the present invention, the transfer of data tothe described buffer may be performed utilizing a DMA controller orengine provided within one or more of SPEs 220-234. Thereafter,load/store unit 318 stores data indicating or specifying a “busy”indicator data value within cacheable memory location 336 of sharedmemory 389 (process block 504).

Once the “busy” indicator data value has been stored, CMU 328 “sets” areservation utilizing reservation register 330 (process block 506) viathe execution of a LDRL instruction. Thereafter, external (e.g., I/O)device 390 may be notified (e.g., by writing to a MMIO register,generating an exception, interrupt, trap, or the like) that theassociated data buffer is ready to be accessed (not show).Alternatively, such a notification may be made merely by the storage ofa buffer “busy” indicator data value within cacheable memory location336 as previously described. Load/store unit 318 then makes adetermination whether the reservation has been reset (process block 508)(e.g., by checking one or more bits of flags within condition register320). Until the reservation is reset, the described LDRL instruction isstalled as shown. While a continuous loop has been utilized to depictthe determination of when a reservation is reset, it should beappreciated that no actual instructions are executed by either theprocessor (in a singly-threaded uni or multi-processor system) or anassociated thread (in a multi-threaded processor system), thus savingvaluable processing and electrical power otherwise wasted utilizingconventional cacheline polling techniques. Once the reservation is reset(e.g., via the storage of a “not busy” indicator data value within thebuffer flag of cacheable memory location 336 by external device 390),the buffer flag data stored within cacheable memory location 336 isloaded by load/store unit 318 into a register of PPU 316 (process block510).

Thereafter, a fixed-point execution unit (not shown) of PPU 316 comparesthe contents of the register of a PPU 316 to which the buffer flag dataof cacheable memory location 336 has been loaded to a specified “busy”indicator data value (process block 512). A branch unit (not shown) ofPPU 316 then utilizes the comparison result, determining whether theregister contents matched “busy” indicator data value (process block514). Thereafter, the depicted process embodiment is either restartedcompletely (process block 502) in response to a determination that theregister contents do not match the known “busy” indicator data value orreentered (process block 506) at the point at which the LDRL instructionwas executed.

Although the operations depicted in FIG. 5 have been described withrespect to specific system elements, the actual elements utilized toperform such operations is immaterial to process embodiments of thepresent invention. Moreover, in alternative embodiments, such operationsmay be performed by any information handling system elements. Similarly,while the flow diagram depicted in FIG. 5 indicates a particular orderof operation and a specific granularity of process operations, inalternative embodiments the illustrated order may be varied (e.g.,process operations may be performed in another order or performedsubstantially in parallel) and one or more of the process operations maybe coalesced or fragmented. Similarly, addition process operations maybe added where necessary in alternative embodiments of the presentinvention.

FIG. 6 shows a block diagram of an exemplary design flow 600 used forexample, in semiconductor IC logic design, simulation, test, layout, andmanufacture. Design flow 600 includes processes and mechanisms forprocessing design structures to generate logically or otherwisefunctionally equivalent representations of the embodiments of theintegrated circuit shown in FIGS. 1-3. The design structures processedand/or generated by design flow 600 may be encoded on machine-readabletransmission or storage media to include data and/or instructions thatwhen executed or otherwise processed on a data processing systemgenerate a logically, structurally, or otherwise functionally equivalentrepresentation of hardware components, circuits, devices, or systems.

FIG. 6 illustrates multiple such design structures including an inputdesign structure 620 that is preferably processed by a design process610. Design structure 620 may be a logical simulation design structuregenerated and processed by design process 610 to produce a logicallyequivalent functional representation of a hardware device. Designstructure 620 may also or alternatively comprise data and/or programinstructions that when processed by design process 610, generate afunctional representation of the physical structure of a hardwaredevice. Whether representing functional and/or structural designfeatures, design structure 620 may be generated using electroniccomputer-aided design (ECAD) such as implemented by a coredeveloper/designer. When encoded on a machine-readable data transmissionor storage medium, design structure 620 may be accessed and processed byone or more hardware and/or software modules within design process 610to simulate or otherwise functionally represent an electronic component,circuit, electronic or logic module, apparatus, device, or system suchas those shown in FIGS. 1-3. As such, design structure 620 may comprisefiles or other data structures including human and/or machine-readablesource code, compiled structures, and computer-executable codestructures that when processed by a design or simulation data processingsystem, functionally simulate or otherwise represent circuits or otherlevels of hardware logic design. Such data structures may includehardware-description language (HDL) design entities or other datastructures conforming to and/or compatible with lower-level HDL designlanguages such as Verilog and VHDL, and/or higher level design languagessuch as C or C++.

Design process 610 preferably employs and incorporates hardware and/orsoftware modules for synthesizing, translating, or otherwise processinga design/simulation functional equivalent of the components, circuits,devices, or logic structures shown in FIGS. 1-3 to generate a netlist680 which may contain design structures such as design structure 620.Netlist 680 may comprise, for example, compiled or otherwise processeddata structures representing a list of wires, discrete components, logicgates, control circuits, I/O devices, models, etc. that describes theconnections to other elements and circuits in an integrated circuitdesign. Netlist 680 may be synthesized using an iterative process inwhich netlist 680 is resynthesized one or more times depending on designspecifications and parameters for the device. As with other designstructure types described herein, netlist 680 may be recorded on amachine-readable data storage medium. The medium may be a non-volatilestorage medium such as a magnetic or optical disk drive, a compactflash, or other flash memory. Additionally, or in the alternative, themedium may be a system or cache memory, buffer space, or electrically oroptically conductive devices and materials on which data packets may betransmitted and intermediately stored via the Internet, or othernetworking suitable means.

Design process 610 may include hardware and software modules forprocessing a variety of input data structure types including netlist680. Such data structure types may reside, for example, within libraryelements 630 and include a set of commonly used elements, circuits, anddevices, including models, layouts, and symbolic representations, for agiven manufacturing technology (e.g., different technology nodes, 32 nm,45 nm, 90 nm, etc.). The data structure types may further include designspecifications 640, characterization data 650, verification data 660,design rules 670, and test data files 685 which may include input testpatterns, output test results, and other testing information. Designprocess 610 may further include modules for performing standard circuitdesign processes such as timing analysis, verification, design rulechecking, place and route operations, etc.

Design process 610 employs and incorporates well-known logic andphysical design tools such as HDL compilers and simulation model buildtools to process design structure 620 together with some or all of thedepicted supporting data structures to generate a second designstructure 690. Similar to design structure 620, design structure 690preferably comprises one or more files, data structures, or othercomputer-encoded data or instructions that reside on transmission ordata storage media and that when processed by an ECAD system generate alogically or otherwise functionally equivalent form of one or more ofthe embodiments of the invention shown in FIGS. 1-3. In one embodiment,design structure 690 may comprise a compiled, executable HDL simulationmodel that functionally simulates the devices shown in FIGS. 1-3.

Design structure 690 may also employ a data format used for the exchangeof layout data of integrated circuits and/or symbolic data format (e.g.information stored in a GDSII (GDS2), GLI, OASIS, map files, or anyother suitable format for storing such design data structures). Designstructure 690 may comprise information such as, for example, symbolicdata, map files, test data files, design content files, manufacturingdata, layout parameters, wires, levels of metal, vias, shapes, data forrouting through the manufacturing line, and any other data processed bysemiconductor manufacturing tools to fabricate embodiments of theinvention as shown in FIGS. 1-3. Design structure 690 may then proceedto a stage 695 where, for example, design structure 690: proceeds totape-out, is released to manufacturing, is released to a mask house, issent to another design house, is sent back to the customer, etc.

Embodiments of the present invention may include software, informationprocessing hardware, and various processing operations further describedherein. The features and process operations of various inventionembodiments may be embodied in executable instructions embodied within amachine-readable medium such as shared memory 289, a storage device, acommunication device or medium, or the like. A machine-readable mediummay include any mechanism that provides (i.e., stores and/or transmits)data in a form readable by a machine (e.g., CBE 200).

For example, a machine-readable medium includes but is not limited to:random access memory (RAM); read only memory (ROM); magnetic storagemedia; optical storage media; flash memory devices; electrical, optical,and/or acoustical propagated signals (e.g., carrier waves, infraredsignals, digital signals, etc.); or the like. The described executableinstructions can be used to cause a general or special purpose processorsuch as PPU 316, programmed with the instructions, to performoperations, methods or processes of the present invention.Alternatively, the features or operations of the present invention maybe performed by specific hardware components that contain hard-wiredlogic for performing such operations, or by any combination ofprogrammed data processing components and custom hardware components.

While the present invention has been described in the context of fullyfunctional data processing system those skilled in the art willappreciate that the present invention is capable of being distributed asa program product in a variety of forms and applies equally regardlessof the particular type of signal bearing media used to carry out thedistribution. Examples of such signal bearing media include recordablemedia such as floppy disks and CD-ROM, transmission type media such asdigital and analog communications links, as well as media storage anddistribution systems developed in the future. Embodiments of the presentinvention may similarly be implemented utilizing software modules usedto perform certain operations or tasks. The described software modulesmay include script, batch, or other executable files and may be storedon a machine-readable or computer-readable medium. Thus, the modules maybe stored within a computer system memory to configure a data processingor computer system to perform one or more functions of a softwaremodule. Other new and various types of machine or computer-readablestorage media may be used to store the modules discussed herein.

While particular embodiments of the present invention have been shownand described, it will be obvious to those skilled in the art that,based upon the teachings herein, changes and modifications may be madewithout departing from this invention and its broader aspects.Consequently, the appended claims are to encompass within their scopeall such changes and modifications as are within the true spirit andscope of this invention and embodiments of the invention are intended tobe limited only by the scope of the appended claims, giving fullcognizance to equivalents in all respects.

1. A design structure embodied in a machine readable medium fordesigning, manufacturing, or testing an integrated circuit, the designstructure comprising: program means for requesting an action by a firstprocess to be performed by a second process; program means for reading amemory location by said first process via a conditional load operationby said first process to determine whether or not said requested actionhas been completed by said second process, and setting a reservation onsaid memory location if said requested action has not been completed;program means for stalling said conditional load operation until saidreservation on said memory location is lost; and program means forresetting said reservation in said memory location by said secondprocess after said action has been completed.
 2. The design structure ofclaim 1, wherein the program means for setting further includes settinga Buffer Busy indicator on said memory location.
 3. The design structureof claim 1, wherein said stalling further includes preventing said loadoperation in a cacheline polling loop from execution until saidreservation has been reset.
 4. The design structure of claim 1, whereinsaid memory location is a cacheable memory location.
 5. The designstructure of claim 1, wherein the design structure comprises a netlist.6. the design structure of claim 1, wherein the design structure resideson storage medium as a data format used for the exchange of layout dataof integrated circuits.
 7. A hardware description language (HDL) designstructure encoded on a machine-readable data storage medium, said HDLdesign structure comprising elements that when processed in acomputer-aided design system generates a machine-executablerepresentation of a cacheline polling logic, wherein said HDL designstructure comprises: a first element processed to generate a functionalcomputer-simulated representation of means for requesting an action by afirst device to be performed by a second device; a second elementprocessed to generate a functional computer-simulated representation ofmeans for reading a memory location by said first process via aconditional load operation by said first process to determine whether ornot said requested action has been completed by said second process, andfor setting a reservation on said memory location if said requestedaction has not been completed; a third element processed to generate afunctional computer-simulated representation of means for stalling saidconditional load operation until said reservation on said memorylocation is lost; and a fourth element processed to generate afunctional computer-simulated representation of means for resetting saidreservation in said memory location by said second device after saidaction has been completed.
 8. The design structure of claim 7, whereinsaid setting means of said first element further includes means forsetting a Buffer Busy indicator on said memory location.
 9. The designstructure of claim 7, wherein said stalling means of said third elementfurther includes means for preventing said load operation in a cachelinepolling loop from execution until said reservation has been reset. 10.The design structure of claim 7, wherein said first device is aprocessor.
 11. The design structure of claim 7, wherein said memorylocation is a cacheable memory location.
 12. A method in acomputer-aided design system for generating a functional design model ofcacheline polling logic, said method comprising: requesting an action bya first process to be performed by a second process; reading a memorylocation by said first process via a conditional load operation by saidfirst process to determine whether or not said requested action has beencompleted by said second process, and setting a reservation on saidmemory location if said requested action has not been completed;stalling said conditional load operation until said reservation on saidmemory location is lost; and resetting said reservation in said memorylocation by said second process after said action has been completed.13. The method of claim 10, wherein said setting further includessetting a Buffer Busy indicator on said memory location.
 14. The methodof claim 10, wherein said stalling further includes preventing said loadoperation in a cacheline polling loop from execution until saidreservation has been reset.
 15. The method of claim 10, wherein saidmemory location is a cacheable memory location.
 16. A design structureembodiment in a machine readable medium for designing, manufacturing ortesting an information handling system, the design structure comprising:a memory comprising a cacheable memory location; and a processingelement coupled to said memory, said processing element comprising aregister to store data specifying a reservation on said cacheable memorylocation; and a load/store unit comprising first load/store logic tostall execution of a conditional load operation targeting said cacheablememory location based upon a state of said data specifying a reservationon said cacheable memory location.
 17. The design structure of claim 16,wherein said load/store unit further comprises second load/store logicto store a buffer flag data value within said cacheable memory location,third load/store logic to store data within said register indicatingsaid reservation on said cacheable memory location is set in response toa storage of said buffer flag data value within said cacheable memorylocation, and said first load/store logic comprises load/store logic tostall execution of said conditional load operation in response to adetermination that said register comprises data indicating saidreservation on said cacheable memory location is reset.
 18. The designstructure of claim 17, wherein said processing element furthercomprises: a cache memory to store data of said cacheable memorylocation; and a cache management unit comprising first cache managementlogic to detect a modification of said buffer flag data value withinsaid cacheable memory location and second cache management logic tostore data within said register indicating said reservation on saidcacheable memory location is reset in response to said modification.